// 成员模板的使用详解
// 成员模板是指在类或类模板内部定义的模板函数或模板类。它们提供了强大的灵活性，让类可以包含能处理各种类型的通用成员函数。
// 1. 基本语法
// 成员模板的基本语法如下：
class MyClass
{
public:
    // 成员模板函数
    template <typename T>
    void process(T value)
    {
        // 处理任何类型的值
        std::cout << "Processing: " << value << std::endl;
    }
};

// 2. 常见应用场景
// 2.1 通用构造函数
class Container
{
private:
    void *data;
    size_t size;

public:
    // 成员模板构造函数 - 可以从任何类型构造
    template <typename T>
    Container(const T &value)
    {
        size = sizeof(T);
        data = new char[size];
        memcpy(data, &value, size);
    }

    ~Container()
    {
        delete[] static_cast<char *>(data);
    }
};

// 使用
Container c1(42);      // T 是 int
Container c2(3.14);    // T 是 double
Container c3("hello"); // T 是 const char*

// 2.2 类模板中的成员模板
template <typename T>
class Stack
{
private:
    std::vector<T> elements;

public:
    // 成员模板 - 可以添加任何可转换为T的类型
    template <typename U>
    void push(const U &element)
    {
        elements.push_back(static_cast<T>(element));
    }

    T pop()
    {
        T top = elements.back();
        elements.pop_back();
        return top;
    }
};

// 使用
Stack<double> numbers;
numbers.push(42);   // U 是 int，转换为 double
numbers.push(3.14); // U 是 double

// 2.3 智能指针转换
// 标准库的智能指针使用成员模板实现派生类到基类的转换：
template <typename T>
class SmartPtr
{
private:
    T *ptr;

public:
    explicit SmartPtr(T *p = nullptr) : ptr(p) {}

    // 成员模板拷贝构造函数
    template <typename U>
    SmartPtr(const SmartPtr<U> &other) : ptr(other.get())
    {
        // 只有当U*可以转换为T*时才能编译
        // 例如：Derived* -> Base*
    }

    T *get() const { return ptr; }

    // 成员模板赋值运算符
    template <typename U>
    SmartPtr &operator=(const SmartPtr<U> &other)
    {
        ptr = other.get();
        return *this;
    }
};

// 使用
class Base
{
};
class Derived : public Base
{
};

SmartPtr<Derived> derived(new Derived);
SmartPtr<Base> base = derived; // 使用成员模板构造函数

// 2.4 泛型算法
class Processor
{
public:
    // 成员模板 - 处理任何容器类型
    template <typename Container>
    void process(const Container &container)
    {
        for (const auto &item : container)
        {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    }
};

// 使用
Processor p;
std::vector<int> vec = {1, 2, 3};
std::list<double> lst = {4.1, 5.2, 6.3};
p.process(vec); // 处理vector
p.process(lst); // 处理list

// 3. 高级用法
// 3.1 成员模板特化
class Converter
{
public:
    // 主模板
    template <typename From, typename To>
    To convert(const From &value)
    {
        return static_cast<To>(value);
    }

    // 特化版本 - 从字符串到整数
    template <>
    int convert<const char *, int>(const char *const &value)
    {
        return std::atoi(value);
    }
};

// 使用
Converter c;
int i = c.convert<double, int>(3.14);       // 使用主模板
int j = c.convert<const char *, int>("42"); // 使用特化版本
